package com.han.practice;

import java.util.*;
import java.io.*;

/**
 * Java编程笔试常用代码模板
 */
public class CommonTemplates {

    // ==================== 1. 输入输出 ====================

    /**
     * 标准输入输出（Scanner）
     */
    public static void ioWithScanner() {
        Scanner sc = new Scanner(System.in);

        // 读取整数
        int n = sc.nextInt();

        // 读取字符串（不含空格）
        String s = sc.next();

        // 读取一行（含空格）
        sc.nextLine(); // 消费换行符
        String line = sc.nextLine();

        // 读取数组
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        // 读取多行直到EOF
        while (sc.hasNext()) {
            String input = sc.nextLine();
            // 处理输入
        }

        sc.close();
    }

    /**
     * 快速输入输出（BufferedReader + PrintWriter）
     */
    public static void fastIO() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取整数
        int n = Integer.parseInt(br.readLine());

        // 读取字符串数组
        String[] tokens = br.readLine().split(" ");

        // 输出
        pw.println("result");
        pw.flush();
        pw.close();
        br.close();
    }

    // ==================== 2. 字符串处理 ====================

    /**
     * 字符串常用操作
     */
    public static void stringOperations() {
        String s = "hello world";

        // 转换为字符数组
        char[] chars = s.toCharArray();

        // 字符串分割
        String[] parts = s.split(" ");

        // 字符串拼接
        StringBuilder sb = new StringBuilder();
        sb.append("hello").append(" ").append("world");
        String result = sb.toString();

        // 字符串反转
        String reversed = new StringBuilder(s).reverse().toString();

        // 判断是否包含子串
        boolean contains = s.contains("hello");

        // 获取子串
        String substring = s.substring(0, 5);

        // 转换大小写
        String upper = s.toUpperCase();
        String lower = s.toLowerCase();

        // 去除首尾空格
        String trimmed = s.trim();
    }

    /**
     * 字符串转数字
     */
    public static void stringToNumber() {
        String numStr = "123";

        // 字符串转整数
        int num = Integer.parseInt(numStr);
        long longNum = Long.parseLong(numStr);

        // 字符串转字符数字
        char c = '5';
        int digit = c - '0';

        // 数字转字符串
        String str1 = String.valueOf(123);
        String str2 = Integer.toString(123);
    }

    // ==================== 3. 数组操作 ====================

    /**
     * 数组常用操作
     */
    public static void arrayOperations() {
        int[] arr = {3, 1, 4, 1, 5};

        // 数组排序
        Arrays.sort(arr);

        // 二分查找
        int index = Arrays.binarySearch(arr, 4);

        // 数组填充
        Arrays.fill(arr, 0);

        // 数组复制
        int[] copy = Arrays.copyOf(arr, arr.length);
        int[] rangeCopy = Arrays.copyOfRange(arr, 1, 3);

        // 打印数组
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 二维数组操作
     */
    public static void matrixOperations() {
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int rows = matrix.length;
        int cols = matrix[0].length;

        // 遍历二维数组
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

    // ==================== 4. 集合操作 ====================

    /**
     * List常用操作
     */
    public static void listOperations() {
        List<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(1);
        list.add(2);

        // 访问元素
        int first = list.get(0);

        // 排序
        Collections.sort(list);

        // 反转
        Collections.reverse(list);

        // 查找
        boolean contains = list.contains(1);
        int index = list.indexOf(1);
    }

    /**
     * Map常用操作
     */
    public static void mapOperations() {
        Map<String, Integer> map = new HashMap<>();

        // 添加/更新
        map.put("key", 1);

        // 获取
        Integer value = map.get("key");
        Integer defaultValue = map.getOrDefault("key", 0);

        // 检查包含
        boolean hasKey = map.containsKey("key");
        boolean hasValue = map.containsValue(1);

        // 遍历
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }

    /**
     * Set常用操作
     */
    public static void setOperations() {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);

        boolean contains = set.contains(1);
    }

    // ==================== 5. 数学运算 ====================

    /**
     * 常用数学函数
     */
    public static void mathOperations() {
        // 最大值/最小值
        int max = Math.max(1, 2);
        int min = Math.min(1, 2);

        // 绝对值
        int abs = Math.abs(-5);

        // 幂运算
        double pow = Math.pow(2, 3); // 2^3 = 8

        // 平方根
        double sqrt = Math.sqrt(16);

        // 向上/向下取整
        double ceil = Math.ceil(3.2); // 4.0
        double floor = Math.floor(3.8); // 3.0

        // 四舍五入
        long round = Math.round(3.6); // 4

        // 随机数
        double random = Math.random(); // [0, 1)
    }

    /**
     * 求最大公约数（GCD）
     */
    public static int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    /**
     * 求最小公倍数（LCM）
     */
    public static int lcm(int a, int b) {
        return a * b / gcd(a, b);
    }

    // ==================== 6. 排序和比较 ====================

    /**
     * 自定义排序
     */
    public static void customSort() {
        List<Integer> list = Arrays.asList(3, 1, 4, 1, 5);

        // 升序
        Collections.sort(list);

        // 降序
        Collections.sort(list, Collections.reverseOrder());

        // 自定义比较器
        List<String> strings = Arrays.asList("apple", "pie", "a");
        Collections.sort(strings, (a, b) -> a.length() - b.length());
    }

    // ==================== 7. 位运算 ====================

    /**
     * 常用位运算
     */
    public static void bitOperations() {
        int n = 10;

        // 判断奇偶
        boolean isOdd = (n & 1) == 1;

        // 获取最低位的1
        int lowBit = n & (-n);

        // 清除最低位的1
        n = n & (n - 1);

        // 设置第i位为1
        int i = 2;
        n = n | (1 << i);

        // 检查第i位是否为1
        boolean isSet = (n & (1 << i)) != 0;

        // 计算二进制中1的个数
        int count = Integer.bitCount(n);
    }

    // ==================== 8. 其他实用工具 ====================

    /**
     * 深拷贝数组
     */
    public static int[] deepCopy(int[] arr) {
        return arr.clone();
    }

    /**
     * 交换数组元素
     */
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 判断回文
     */
    public static boolean isPalindrome(String s) {
        int left = 0, right = s.length() - 1;
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

    /**
     * 主函数 - 示例用法
     */
    public static void main(String[] args) throws IOException {
        // 这里可以测试各种功能
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个数字：");
        int n = sc.nextInt();
        System.out.println("输入的数字是：" + n);
        sc.close();
    }
}